home *** CD-ROM | disk | FTP | other *** search
/ SuperHack / SuperHack CD.bin / CODING / C / THESRC20.ZIP / COMMSET2.C < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-26  |  83.7 KB  |  2,715 lines
  1. /***********************************************************************/
  2. /* COMMSET2.C - SET commands O-Z                                       */
  3. /***********************************************************************/
  4. /*
  5.  * THE - The Hessling Editor. A text editor similar to VM/CMS xedit.
  6.  * Copyright (C) 1991-1995 Mark Hessling
  7.  *
  8.  * This program is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU General Public License as
  10.  * published by the Free Software Foundation; either version 2 of
  11.  * the License, or any later version.
  12.  *
  13.  * This program is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16.  * General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU General Public License
  19.  * along with this program; if not, write to:
  20.  *
  21.  *    The Free Software Foundation, Inc.
  22.  *    675 Mass Ave,
  23.  *    Cambridge, MA 02139 USA.
  24.  *
  25.  *
  26.  * If you make modifications to this software that you feel increases
  27.  * it usefulness for the rest of the community, please email the
  28.  * changes, enhancements, bug fixes as well as any and all ideas to me.
  29.  * This software is going to be maintained and enhanced as deemed
  30.  * necessary by the community.
  31.  *
  32.  * Mark Hessling                     email: M.Hessling@gu.edu.au
  33.  * 36 David Road                     Phone: +61 7 849 7731
  34.  * Holland Park                      Fax:   +61 7 875 5314
  35.  * QLD 4121
  36.  * Australia
  37.  */
  38.  
  39. /*
  40. $Id: commset2.c 2.0 1995/01/26 16:30:13 MH Release MH $
  41. */
  42.  
  43. #include <stdio.h>
  44.  
  45. #include "the.h"
  46. #include "proto.h"
  47.  
  48. /*#define DEBUG 1*/
  49.  
  50. /*--------------------------- global data -----------------------------*/
  51. bool rexx_output=FALSE;
  52. /*man-start*********************************************************************
  53. COMMAND
  54.      pending - set status of pending prefix commands
  55.  
  56. SYNTAX
  57.      [SET] PENDing ON string
  58.      [SET] PENDing OFF
  59.      [SET] PENDing BLOCK string
  60.  
  61. DESCRIPTION
  62.      The PENDING command allows the user to insert or remove commands
  63.      from the pending prefix list.
  64.  
  65.      ON string, simulates the user typing 'string' in the PREFIX area
  66.      of the focus line.
  67.  
  68.      OFF, removes any pending prefix command from the focus line.
  69.  
  70.      BLOCK string, simulates the user typing 'string' in the PREFIX
  71.      area of the focus line and identifies the prefix command to be 
  72.      a BLOCK command.
  73.  
  74. COMPATIBILITY
  75.      XEDIT: Does not support ERROR option.
  76.      KEDIT: N/A
  77.  
  78. STATUS
  79.      Complete.
  80. **man-end**********************************************************************/
  81. #ifdef PROTO
  82. short Pending(CHARTYPE *params)
  83. #else
  84. short Pending(params)
  85. CHARTYPE *params;
  86. #endif
  87. /***********************************************************************/
  88. {
  89. #define PEND_ON    1
  90. #define PEND_OFF   2
  91. #define PEND_BLOCK 3
  92. /*------------------------- external data -----------------------------*/
  93.  extern bool in_profile;
  94.  extern CHARTYPE *pre_rec;
  95.  extern unsigned short pre_rec_len;
  96. /*--------------------------- local data ------------------------------*/
  97. #define PEN_PARAMS  3
  98.  CHARTYPE *word[PEN_PARAMS+1];
  99.  unsigned short num_params=0;
  100.  short rc=RC_OK;
  101.  LINE *curr=NULL;
  102.  LINETYPE true_line=0L;
  103.  short command=0;
  104. /*--------------------------- processing ------------------------------*/
  105. #ifdef TRACE
  106.  trace_function("commset2.c:Pending");
  107. #endif
  108. /*---------------------------------------------------------------------*/
  109. /* Validate parameters.                                                */
  110. /*---------------------------------------------------------------------*/
  111.  num_params = param_split(params,word,PEN_PARAMS,WORD_DELIMS,TEMP_PARAM);
  112. /*---------------------------------------------------------------------*/
  113. /* If no arguments, error.                                             */
  114. /*---------------------------------------------------------------------*/
  115.  if (num_params == 0)
  116.    {
  117.     display_error(3,(CHARTYPE *)"",FALSE);
  118. #ifdef TRACE
  119.     trace_return();
  120. #endif
  121.     return(RC_INVALID_OPERAND);
  122.    }
  123. /*---------------------------------------------------------------------*/
  124. /* If more than 2 arguments, error.                                    */
  125. /*---------------------------------------------------------------------*/
  126.  if (num_params > 2)
  127.    {
  128.     display_error(2,(CHARTYPE *)"",FALSE);
  129. #ifdef TRACE
  130.     trace_return();
  131. #endif
  132.     return(RC_INVALID_OPERAND);
  133.    }
  134. /*---------------------------------------------------------------------*/
  135. /* Validate first parameter...                                         */
  136. /*---------------------------------------------------------------------*/
  137.  if (equal((CHARTYPE *)"off",word[0],3))
  138.     command = PEND_OFF;
  139.  else
  140.     if (equal((CHARTYPE *)"on",word[0],2))
  141.        command = PEND_ON;
  142.     else
  143.        if (equal((CHARTYPE *)"block",word[0],5))
  144.           command = PEND_BLOCK;
  145.        else
  146.          {
  147.           display_error(1,word[0],FALSE);
  148. #ifdef TRACE
  149.           trace_return();
  150. #endif
  151.           return(RC_INVALID_OPERAND);
  152.          }
  153.  true_line = get_true_line();
  154.  post_process_line(CURRENT_VIEW,CURRENT_VIEW->focus_line);
  155.  switch(command)
  156.    {
  157. /*---------------------------------------------------------------------*/
  158. /* PENDING ON and PENDING BLOCK...                                     */
  159. /*---------------------------------------------------------------------*/
  160.     case PEND_ON:
  161.     case PEND_BLOCK:
  162. /*---------------------------------------------------------------------*/
  163. /* The second argument must be present and <= PREFIX_WIDTH.            */
  164. /*---------------------------------------------------------------------*/
  165.          if (num_params != 2)
  166.            {
  167.             display_error(3,(CHARTYPE *)"",FALSE);
  168.             rc = RC_INVALID_OPERAND;
  169.             break;
  170.            }
  171.          if (strlen(word[1]) > PREFIX_WIDTH)
  172.            {
  173.             display_error(1,word[1],FALSE); /* different error ?? */
  174.             rc = RC_INVALID_OPERAND;
  175.             break;
  176.            }
  177. /*---------------------------------------------------------------------*/
  178. /* Copy the string into pre_rec and set its length.                    */
  179. /*---------------------------------------------------------------------*/
  180.          memset(pre_rec,' ',PREFIX_WIDTH);
  181.          strcpy(pre_rec,word[1]);
  182.          pre_rec_len = strlen(word[1]);
  183.          pre_rec[pre_rec_len] = ' ';
  184.          pre_rec[PREFIX_WIDTH] = '\0';
  185.          curr = lll_find(CURRENT_FILE->first_line,true_line);
  186.          if (command == PEND_BLOCK)
  187.             add_prefix_command(curr,true_line,TRUE);
  188.          else
  189.             add_prefix_command(curr,true_line,FALSE);
  190.          break;
  191. /*---------------------------------------------------------------------*/
  192. /* PENDING OFF...                                                      */
  193. /*---------------------------------------------------------------------*/
  194.     case PEND_OFF:
  195.          if (num_params != 1)
  196.            {
  197.             display_error(2,(CHARTYPE *)"",FALSE);
  198.             rc = RC_INVALID_OPERAND;
  199.             break;
  200.            }
  201.          curr = lll_find(CURRENT_FILE->first_line,true_line);
  202.          (void)delete_pending_prefix_command(curr->pre,CURRENT_FILE,curr);
  203.          memset(pre_rec,' ',PREFIX_WIDTH);
  204.          pre_rec_len = 0;
  205.          break;
  206.    }
  207.  if (rc == RC_OK)
  208.    {
  209.     build_current_screen();
  210.     display_current_screen();
  211.    }
  212. #ifdef TRACE
  213.  trace_return();
  214. #endif
  215.  return(rc);
  216. }
  217. /*man-start*********************************************************************
  218. COMMAND
  219.      point - assign a name to the current line
  220.  
  221. SYNTAX
  222.      [SET] Point .name [OFF]
  223.  
  224. DESCRIPTION
  225.      The POINT command assignes the specified name to the current
  226.      line, or removes the name from the line with the specified name.
  227.      A valid line name must start with a '.' followed by an alphabetic
  228.      character. eg. .a .fred and .GG are valid names; fred and .3 are
  229.      invalid line names.
  230.  
  231.      When a line is moved within the same file, its line name stays
  232.      with the line.
  233.  
  234. COMPATIBILITY
  235.      XEDIT: Compatible. See below.
  236.      KEDIT: Compatible. See below.
  237.      Does not allow for multiple names for the same line.
  238.  
  239. STATUS
  240.      Complete.
  241. **man-end**********************************************************************/
  242. #ifdef PROTO
  243. short Point(CHARTYPE *params)
  244. #else
  245. short Point(params)
  246. CHARTYPE *params;
  247. #endif
  248. /***********************************************************************/
  249. {
  250. /*------------------------- external date -----------------------------*/
  251. /*--------------------------- local data ------------------------------*/
  252. #define POI_PARAMS  2
  253.  CHARTYPE *word[POI_PARAMS+1];
  254.  unsigned short num_params=0;
  255.  short rc=RC_OK;
  256. /*--------------------------- processing ------------------------------*/
  257. #ifdef TRACE
  258.  trace_function("commset2.c:Point");
  259. #endif
  260. /*---------------------------------------------------------------------*/
  261. /* Validate parameters.                                                */
  262. /*---------------------------------------------------------------------*/
  263.  num_params = param_split(params,word,POI_PARAMS,WORD_DELIMS,TEMP_PARAM);
  264.  if (num_params < 1)
  265.    {
  266.     display_error(3,(CHARTYPE *)"",FALSE);
  267. #ifdef TRACE
  268.     trace_return();
  269. #endif
  270.     return(RC_INVALID_OPERAND);
  271.    }
  272. /*---------------------------------------------------------------------*/
  273. /* Turning on line name...                                             */
  274. /*---------------------------------------------------------------------*/
  275.  if (num_params == 1)
  276.    {
  277.     if (word[0][0] != '.'
  278.     ||  !isalpha(word[0][1]))
  279.       {
  280.        display_error(18,word[0],FALSE);
  281. #ifdef TRACE
  282.        trace_return();
  283. #endif
  284.        return(RC_INVALID_OPERAND);
  285.       }
  286.     if ((rc = execute_set_point(word[0],get_true_line(),TRUE)) != RC_OK)
  287.       {
  288. #ifdef TRACE
  289.        trace_return();
  290. #endif
  291.        return(rc);
  292.       }
  293.    }
  294. /*---------------------------------------------------------------------*/
  295. /* Turning off line name...                                            */
  296. /*---------------------------------------------------------------------*/
  297.  else
  298.    {
  299.     if (!equal((CHARTYPE *)"off",word[1],3))
  300.       {
  301.        display_error(1,word[1],FALSE);
  302. #ifdef TRACE
  303.        trace_return();
  304. #endif
  305.        return(RC_INVALID_OPERAND);
  306.       }
  307.     if ((rc = execute_set_point(word[0],get_true_line(),FALSE)) != RC_OK)
  308.       {
  309. #ifdef TRACE
  310.        trace_return();
  311. #endif
  312.        return(rc);
  313.       }
  314.    }
  315. #ifdef TRACE
  316.  trace_return();
  317. #endif
  318.  return(RC_OK);
  319. }
  320. /*man-start*********************************************************************
  321. COMMAND
  322.      position - determine if LINE/COL is displayed on IDLINE
  323.  
  324. SYNTAX
  325.      [SET] POSition ON|OFF
  326.  
  327. DESCRIPTION
  328.      The POSITION command allows the user to turn on or off the
  329.      display of LINE/COL on the IDLINE.
  330.  
  331. COMPATIBILITY
  332.      XEDIT: N/A
  333.      KEDIT: N/A
  334.  
  335. DEFAULT
  336.      ON
  337.  
  338. STATUS
  339.      Complete.
  340. **man-end**********************************************************************/
  341. #ifdef PROTO
  342. short Position(CHARTYPE *params)
  343. #else
  344. short Position(params)
  345. CHARTYPE *params;
  346. #endif
  347. /***********************************************************************/
  348. {
  349. /*------------------------- external date -----------------------------*/
  350. /*--------------------------- local data ------------------------------*/
  351.  short rc=RC_OK;
  352. /*--------------------------- processing ------------------------------*/
  353. #ifdef TRACE
  354.  trace_function("commset2.c:Position");
  355. #endif
  356.  rc = execute_set_on_off(params,&CURRENT_VIEW->position_status);
  357. #ifdef TRACE
  358.  trace_return();
  359. #endif
  360.  return(rc);
  361. }
  362. /*man-start*********************************************************************
  363. COMMAND
  364.      prefix - set prefix area attributes
  365.  
  366. SYNTAX
  367.      [SET] PREfix ON [Left|Right]
  368.      [SET] PREfix Nulls [Left|Right]
  369.      [SET] PREfix OFF
  370.      [SET] PREfix Synonym newname oldname
  371.  
  372. DESCRIPTION
  373.      The first form of the PREFIX command allows the user to display
  374.      the prefix area and optionally to select the position the prefix
  375.      should be displayed at.
  376.  
  377.      The second form of the PREFIX command is functionally the same
  378.      as the first form. The difference is that when the prefix area
  379.      is displayed with NUMBER ON, numbers are displyed with leading
  380.      spaces rather than zeros; with NUMBER OFF, blanks are displayed
  381.      instead of equal signs.
  382.  
  383.      The third form, turns the display of the prefix area off.
  384.      Executed from within the profile, the only effect is that the
  385.      defaults for all files is changed.
  386.      Executed from the command line, the PREFIX command changes the
  387.      current window displays to reflect the required options.
  388.  
  389.      The fourth form of the PREFIX command allows the users to specify
  390.      a synonym for a prefix command or REXX prefix macro. The 'newname'
  391.      is the command entered in the prefix area and 'oldname' corresponds
  392.      to an existing prefix command or a REXX macro file in the MACROPATH
  393.      ending in .the or whatever the value of MACROEXT is at the time the
  394.      prefix command is executed. The 'oldname' can also be the fully
  395.      qualified filename of a REXX macro.
  396.  
  397. COMPATIBILITY
  398.      XEDIT: Compatible. See below.
  399.      KEDIT: Compatible. See below.
  400.  
  401. DEFAULT
  402.      ON LEFT
  403.  
  404. STATUS
  405.      Complete.
  406. **man-end**********************************************************************/
  407. #ifdef PROTO
  408. short Prefix(CHARTYPE *params)
  409. #else
  410. short Prefix(params)
  411. CHARTYPE *params;
  412. #endif
  413. /***********************************************************************/
  414. {
  415. /*-------------------------- external data ----------------------------*/
  416.  extern bool curses_started;
  417.  extern short prefix_width;
  418. /*--------------------------- local data ------------------------------*/
  419. #define PRE_PARAMS  4
  420.  CHARTYPE *word[PRE_PARAMS+1];
  421.  CHARTYPE prefix=PREFIX_OFF;
  422.  CHARTYPE previous_prefix=CURRENT_VIEW->prefix;
  423.  unsigned short num_params=0;
  424.  short rc=RC_OK;
  425. /*--------------------------- processing ------------------------------*/
  426. #ifdef TRACE
  427.  trace_function("commset2.c:Prefix");
  428. #endif
  429.  num_params = param_split(params,word,PRE_PARAMS,WORD_DELIMS,TEMP_PARAM);
  430.  if (equal((CHARTYPE *)"on",word[0],2)
  431.  ||  equal((CHARTYPE *)"nulls",word[0],1))
  432.    {
  433.     if (num_params > 2)
  434.       {
  435.        display_error(2,(CHARTYPE *)"",FALSE);
  436. #ifdef TRACE
  437.        trace_return();
  438. #endif
  439.        return(RC_INVALID_OPERAND);
  440.       }
  441.     if (equal((CHARTYPE *)"left",word[1],1))
  442.        prefix = PREFIX_LEFT;
  443.     else
  444.        if (equal((CHARTYPE *)"right",word[1],1))
  445.           prefix = PREFIX_RIGHT;
  446.        else
  447.           if (num_params == 1)       /* no left/right, default to left */
  448.              prefix = PREFIX_LEFT;
  449.           else
  450.             {
  451.              display_error(1,word[1],FALSE);
  452. #ifdef TRACE
  453.              trace_return();
  454. #endif
  455.              return(RC_INVALID_OPERAND);
  456.             }
  457.     if (equal((CHARTYPE *)"on",word[0],2))
  458.        CURRENT_VIEW->prefix = prefix | PREFIX_ON;
  459.     else
  460.        CURRENT_VIEW->prefix = prefix | PREFIX_NULLS;
  461.    }
  462.  else
  463.    {
  464.     if (equal((CHARTYPE *)"off",word[0],3))
  465.       {
  466.        if (num_params > 1)
  467.          {
  468.           display_error(2,(CHARTYPE *)"",FALSE);
  469. #ifdef TRACE
  470.           trace_return();
  471. #endif
  472.           return(RC_INVALID_OPERAND);
  473.          }
  474.        if (strcmp(word[1],"") == 0)
  475.           CURRENT_VIEW->prefix = PREFIX_OFF;
  476.        else
  477.          {
  478.           display_error(2,word[1],FALSE);
  479. #ifdef TRACE
  480.           trace_return();
  481. #endif
  482.           return(RC_INVALID_OPERAND);
  483.          }
  484.       }
  485.     else
  486.        if (equal((CHARTYPE *)"synonym",word[0],1))
  487.          {
  488.           if (num_params < 3)
  489.             {
  490.              display_error(3,(CHARTYPE *)"",FALSE);
  491. #ifdef TRACE
  492.              trace_return();
  493. #endif
  494.              return(RC_INVALID_OPERAND);
  495.             }
  496.           if (num_params > 3)
  497.             {
  498.              display_error(2,(CHARTYPE *)"",FALSE);
  499. #ifdef TRACE
  500.              trace_return();
  501. #endif
  502.              return(RC_INVALID_OPERAND);
  503.             }
  504.           if (strlen(word[1]) > PREFIX_WIDTH)
  505.             {
  506.              display_error(37,word[1],FALSE);
  507. #ifdef TRACE
  508.              trace_return();
  509. #endif
  510.              return(RC_INVALID_OPERAND);
  511.             }
  512.           rc = add_prefix_synonym(word[1],word[2]);
  513. #ifdef TRACE
  514.           trace_return();
  515. #endif
  516.           return(rc);
  517.          }
  518.        else
  519.          {
  520.           display_error(1,word[0],FALSE);
  521. #ifdef TRACE
  522.           trace_return();
  523. #endif
  524.           return(RC_INVALID_OPERAND);
  525.          }
  526.    }
  527. /*---------------------------------------------------------------------*/
  528. /* If the new setting for PREFIX is identical with the previous values */
  529. /* don't do anything more.                                             */
  530. /*---------------------------------------------------------------------*/
  531.  if (previous_prefix == CURRENT_VIEW->prefix)
  532.    {
  533. #ifdef TRACE
  534.     trace_return();
  535. #endif
  536.     return(RC_OK);
  537.    }
  538. /*---------------------------------------------------------------------*/
  539. /* If the new location for PREFIX is the same as the previous value,   */
  540. /* then the only difference MUST be the status, so just rebuild and    */
  541. /* display the screen.                                                 */
  542. /*---------------------------------------------------------------------*/
  543.  if ((previous_prefix&PREFIX_LOCATION_MASK) == (CURRENT_VIEW->prefix&PREFIX_LOCATION_MASK))
  544.    {
  545.     build_current_screen();
  546.     display_current_screen();
  547. #ifdef TRACE
  548.     trace_return();
  549. #endif
  550.     return(RC_OK);
  551.    }
  552. /*---------------------------------------------------------------------*/
  553. /* To get here the location of the window has changed, so rebuild the  */
  554. /* windows and display the screen.                                     */
  555. /*---------------------------------------------------------------------*/
  556.  set_screen_defaults();
  557.  if (set_up_windows(current_screen) != RC_OK)
  558.    {
  559. #ifdef TRACE
  560.     trace_return();
  561. #endif
  562.     return(RC_OK);
  563.    }
  564.  build_current_screen();
  565.  display_current_screen();
  566. #ifdef TRACE
  567.  trace_return();
  568. #endif
  569.  return(RC_OK);
  570. }
  571. /*man-start*********************************************************************
  572. COMMAND
  573.      printer - define printer spooler name
  574.  
  575. SYNTAX
  576.      [SET] PRINTER spooler
  577.  
  578. DESCRIPTION
  579.      The PRINTER command sets up the print spooler name to determine
  580.      where output from the PRINT command goes.
  581.  
  582. COMPATIBILITY
  583.      XEDIT: N/A
  584.      KEDIT: Compatible.
  585.  
  586. DEFAULT
  587.      LPT1 - DOS/OS2, lpr - Unix
  588.  
  589. SEE ALSO
  590.      PRINT
  591.  
  592. STATUS
  593.      Complete. 
  594. **man-end**********************************************************************/
  595. #ifdef PROTO
  596. short THEPrinter(CHARTYPE *params)
  597. #else
  598. short THEPrinter(params)
  599. CHARTYPE *params;
  600. #endif
  601. /***********************************************************************/
  602. {
  603. /*------------------------- external date -----------------------------*/
  604. #if defined(UNIX) || defined(OS2)
  605.  extern CHARTYPE *spooler_name;
  606. /*--------------------------- processing ------------------------------*/
  607. #ifdef TRACE
  608.  trace_function("commset2.c:THEPrinter");
  609. #endif
  610.  if ((spooler_name = (CHARTYPE *)(*the_realloc)(spooler_name,strlen(params)+1)) == NULL)
  611.    {
  612.     display_error(30,(CHARTYPE *)"",FALSE);
  613. #ifdef TRACE
  614.     trace_return();
  615. #endif
  616.     return(RC_OUT_OF_MEMORY);
  617.    }
  618.  strcpy(spooler_name,params);
  619. #endif
  620. #ifdef TRACE
  621.  trace_return();
  622. #endif
  623.  return(RC_OK);
  624. }
  625. /*man-start*********************************************************************
  626. COMMAND
  627.      reprofile - indicate if profile file to be executed for all files
  628.  
  629. SYNTAX
  630.      [SET] REPROFile ON|OFF
  631.  
  632. DESCRIPTION
  633.      The REPROFILE command allows the user to determine if the profile
  634.      file is to reexecuted for files subsequenlty edited.
  635.  
  636. COMPATIBILITY
  637.      XEDIT: N/A
  638.      KEDIT: Compatible.
  639.  
  640. DEFAULT
  641.      OFF
  642.  
  643. SEE ALSO
  644.      XEDIT
  645.  
  646. STATUS
  647.      Complete
  648. **man-end**********************************************************************/
  649. #ifdef PROTO
  650. short Reprofile(CHARTYPE *params)
  651. #else
  652. short Reprofile(params)
  653. CHARTYPE *params;
  654. #endif
  655. /***********************************************************************/
  656. {
  657. /*-------------------------- external data ----------------------------*/
  658.  extern bool REPROFILEx;
  659. /*--------------------------- local data ------------------------------*/
  660.  short rc=RC_OK;
  661. /*--------------------------- processing ------------------------------*/
  662. #ifdef TRACE
  663.  trace_function("commset2.c:Reprofile");
  664. #endif
  665.  rc = execute_set_on_off(params,&REPROFILEx);
  666. #ifdef TRACE
  667.  trace_return();
  668. #endif
  669.  return(rc);
  670. }
  671. /*man-start*********************************************************************
  672. COMMAND
  673.      reserved - display a reserved line
  674.  
  675. SYNTAX
  676.      [SET] RESERved +|-n [colour] text|OFF
  677.  
  678. DESCRIPTION
  679.      The RESERVED command reseves a line for the display of arbitrary
  680.      text by the user. The position is determined by +|-n.
  681.      This number, if positive, specifies the line relative from the
  682.      top of the display. A negative number is relative from the
  683.      bottom of the display.
  684.  
  685.      By specifying a line, say +3, then THREE lines from the top will
  686.      be reserved, with the supplied text being displayed in line 3.
  687.  
  688.      The idline of a file will always be displayed after any reserved
  689.      lines.
  690.  
  691.      The status area will always be displayed on the very last line
  692.      of the screen and any reserved lines will display above that.
  693.      The status area then is effectively line -0.
  694.  
  695.      The colour option specifies the colours to use to display the
  696.      reserved line.
  697.  
  698. COMPATIBILITY
  699.      XEDIT: Compatible.
  700.      KEDIT: Compatible.
  701.  
  702. SEE ALSO
  703.      SET COLOUR
  704.  
  705. STATUS
  706.      Complete.
  707. **man-end**********************************************************************/
  708. #ifdef PROTO
  709. short Reserved(CHARTYPE *params)
  710. #else
  711. short Reserved(params)
  712. CHARTYPE *params;
  713. #endif
  714. /***********************************************************************/
  715. {
  716. /*--------------------------- local data ------------------------------*/
  717. #define RSR_PARAMS  2
  718.  CHARTYPE *word[RSR_PARAMS+1];
  719.  unsigned short num_params=0;
  720.  short base=0,off=0;
  721.  COLOUR_ATTR attr={0},save_attr={0};
  722.  CHARTYPE *string=NULL;
  723.  short rc=RC_OK;
  724. /*--------------------------- processing ------------------------------*/
  725. #ifdef TRACE
  726.  trace_function("commset2.c:Reserved");
  727. #endif
  728.  num_params = param_split(params,word,RSR_PARAMS,WORD_DELIMS,TEMP_PARAM);
  729.  if (num_params < 2)
  730.     {
  731.      display_error(3,(CHARTYPE *)"",FALSE);
  732. #ifdef TRACE
  733.      trace_return();
  734. #endif
  735.      return(RC_INVALID_OPERAND);
  736.     }
  737. /*---------------------------------------------------------------------*/
  738. /* Parse the position parameter...                                     */
  739. /*---------------------------------------------------------------------*/
  740.  rc = execute_set_row_position(word[0],&base,&off);
  741.  if (rc != RC_OK)
  742.    {
  743. #ifdef TRACE
  744.     trace_return();
  745. #endif
  746.     return(rc);
  747.    }
  748.  if (equal((CHARTYPE *)"OFF",word[1],3))
  749.     rc = delete_reserved_line(base,off);
  750.  else
  751.    {
  752. /*---------------------------------------------------------------------*/
  753. /* Parse the colour arguments (if any)...                              */
  754. /*---------------------------------------------------------------------*/
  755.     if ((rc = parse_colours(word[1],&attr,&string,TRUE)) != RC_OK)
  756.       {
  757. #ifdef TRACE
  758.        trace_return();
  759. #endif
  760.        return(rc);
  761.       }
  762. /*---------------------------------------------------------------------*/
  763. /* If no colours were specified, use the default colour as set by any  */
  764. /* SET COLOUR RESERVED... command.                                     */
  765. /*---------------------------------------------------------------------*/
  766.     if (memcmp(&attr,&save_attr,sizeof(COLOUR_ATTR)) == 0)
  767.        rc = add_reserved_line(word[0],string,base,off,CURRENT_FILE->attr+ATTR_RESERVED);
  768.     else
  769.        rc = add_reserved_line(word[0],string,base,off,&attr);
  770.    }
  771.  build_current_screen();
  772.  display_current_screen();
  773. #ifdef TRACE
  774.  trace_return();
  775. #endif
  776.  return(rc);
  777. }
  778. /*man-start*********************************************************************
  779. COMMAND
  780.      rexxoutput - indicate where REXX output is to go
  781.  
  782. SYNTAX
  783.      [SET] REXXOUTput File|Display n
  784.  
  785. DESCRIPTION
  786.      The REXXOUTPUT command indicates where output from the REXX
  787.      interpreter is to go; either captured to a file in the ring
  788.      or displayed in a scrolling fashion on the screen.
  789.  
  790.      Also specified is the maximum number of lines from the REXX
  791.      interpreter that are to be displayed or captured. This is
  792.      particularly useful when a REXX macro gets into an infinite
  793.      loop.
  794.  
  795. COMPATIBILITY
  796.      XEDIT: N/A
  797.      KEDIT: N/A
  798.  
  799. DEFAULT
  800.      DISPLAY 1000
  801.  
  802. STATUS
  803.      Complete.
  804. **man-end**********************************************************************/
  805. #ifdef PROTO
  806. short Rexxoutput(CHARTYPE *params)
  807. #else
  808. short Rexxoutput(params)
  809. CHARTYPE *params;
  810. #endif
  811. /***********************************************************************/
  812. {
  813. /*-------------------------- external data ----------------------------*/
  814.  extern LINETYPE CAPREXXMAXx;
  815.  extern bool CAPREXXOUTx;
  816.  extern bool rexx_output;
  817. /*--------------------------- local data ------------------------------*/
  818. #define REX_PARAMS  2
  819.  CHARTYPE *word[REX_PARAMS+1];
  820.  unsigned short num_params=0;
  821. /*--------------------------- processing ------------------------------*/
  822. #ifdef TRACE
  823.  trace_function("commset2.c:Rexxoutput");
  824. #endif
  825.  if (rexx_output)
  826.    {
  827.     display_error(0,(CHARTYPE *)"Error: Unable to alter REXXOUTPUT settings",FALSE);
  828. #ifdef TRACE
  829.     trace_return();
  830. #endif
  831.     return(RC_INVALID_OPERAND);
  832.    }
  833.  num_params = param_split(params,word,REX_PARAMS,WORD_DELIMS,TEMP_PARAM);
  834.  if (num_params < 2)
  835.    {
  836.     display_error(3,(CHARTYPE *)"",FALSE);
  837. #ifdef TRACE
  838.     trace_return();
  839. #endif
  840.     return(RC_INVALID_OPERAND);
  841.    }
  842.  if (equal((CHARTYPE *)"file",word[0],1))
  843.     CAPREXXOUTx = TRUE;
  844.  else
  845.     if (equal((CHARTYPE *)"display",word[0],1))
  846.        CAPREXXOUTx = FALSE;
  847.     else
  848.       {
  849.        display_error(1,(CHARTYPE *)word[0],FALSE);
  850. #ifdef TRACE
  851.        trace_return();
  852. #endif
  853.        return(RC_INVALID_OPERAND);
  854.       }
  855.  if (!valid_positive_integer(word[1]))
  856.    {
  857.     display_error(4,(CHARTYPE *)word[1],FALSE);
  858. #ifdef TRACE
  859.     trace_return();
  860. #endif
  861.     return(RC_INVALID_OPERAND);
  862.    }
  863.  CAPREXXMAXx =  atol(word[1]);
  864.  return(RC_OK);
  865. }
  866. /*man-start*********************************************************************
  867. COMMAND
  868.      scale - set position and status of scale line on screen
  869.  
  870. SYNTAX
  871.      [SET] SCALE ON|OFF [M[+n|-n]|[+|-]n]
  872.  
  873. DESCRIPTION
  874.      The SCALE command sets the position and status of the scale line
  875.      for the current view.
  876.  
  877.      The two forms of the position parameters are:
  878.      M[+n|-n] - this sets the scale line to be relative to the
  879.                 middle of the screen. A positive value adds to the
  880.                 middle line number, a negative subtracts from it.
  881.                 eg. M+3 on a 24 line screen will be line 15
  882.                     M-5 on a 24 line screen will be line 7
  883.  
  884.      [+|-]n   - this sets the scale line to be relative to the
  885.                 top of the screen (if positive or no sign) or
  886.                 relative to the bottom of the screen if negative.
  887.                 eg. +3 or 3 will set scale line to line 3
  888.                     -3 on a 24 line screen will be line 21
  889.  
  890.      If the resulting line is outside the bounds of the screen
  891.      the position of the current line will become the middle line
  892.      on the screen.
  893.  
  894. COMPATIBILITY
  895.      XEDIT: Compatible.
  896.      KEDIT: Compatible.
  897.  
  898. DEFAULT
  899.      OFF M+1
  900.  
  901. STATUS
  902.      Complete.
  903. **man-end**********************************************************************/
  904. #ifdef PROTO
  905. short Scale(CHARTYPE *params)
  906. #else
  907. short Scale(params)
  908. CHARTYPE *params;
  909. #endif
  910. /***********************************************************************/
  911. {
  912. /*-------------------------- external data ----------------------------*/
  913. /*--------------------------- local data ------------------------------*/
  914. #define SCA_PARAMS  2
  915.  CHARTYPE *word[SCA_PARAMS+1];
  916.  short num_params=0;
  917.  short rc=RC_OK;
  918.  short base=(short)CURRENT_VIEW->scale_base;
  919.  short off=CURRENT_VIEW->scale_off;
  920.  bool scalests=FALSE;
  921. /*--------------------------- processing ------------------------------*/
  922. #ifdef TRACE
  923.  trace_function("commset2.c:Scale");
  924. #endif
  925.  num_params = param_split(params,word,SCA_PARAMS,WORD_DELIMS,TEMP_PARAM);
  926.  if (num_params < 1)
  927.    {
  928.     display_error(3,(CHARTYPE *)"",FALSE);
  929. #ifdef TRACE
  930.     trace_return();
  931. #endif
  932.     return(RC_INVALID_OPERAND);
  933.    }
  934. /*---------------------------------------------------------------------*/
  935. /* Parse the status parameter...                                       */
  936. /*---------------------------------------------------------------------*/
  937.  rc = execute_set_on_off(word[0],&scalests);
  938.  if (rc != RC_OK)
  939.    {
  940. #ifdef TRACE
  941.     trace_return();
  942. #endif
  943.     return(rc);
  944.    }
  945. /*---------------------------------------------------------------------*/
  946. /* Parse the position parameter...                                     */
  947. /*---------------------------------------------------------------------*/
  948.  if (num_params > 1)
  949.    {
  950.     rc = execute_set_row_position(word[1],&base,&off);
  951.     if (rc != RC_OK)
  952.       {
  953. #ifdef TRACE
  954.        trace_return();
  955. #endif
  956.        return(rc);
  957.       }
  958.    }
  959.  CURRENT_VIEW->scale_base = (CHARTYPE)base;
  960.  CURRENT_VIEW->scale_off = off;
  961.  CURRENT_VIEW->scale_on = scalests;
  962.  post_process_line(CURRENT_VIEW,CURRENT_VIEW->focus_line);
  963.  build_current_screen();
  964.  display_current_screen();
  965. #ifdef TRACE
  966.  trace_return();
  967. #endif
  968.  return(RC_OK);
  969. }
  970. /*man-start*********************************************************************
  971. COMMAND
  972.      scope - sets which lines are to be excluded from commands
  973.  
  974. SYNTAX
  975.      [SET] SCOPE All|Display
  976.  
  977. DESCRIPTION
  978.      The SCOPE command indicates whether lines not displayed as
  979.      the result of a SET DISPLAY or ALL command are included in
  980.      the scope of lines to be acted upon by other THE commands.
  981.  
  982. COMPATIBILITY
  983.      XEDIT: Compatible.
  984.      KEDIT: Compatible.
  985.  
  986. DEFAULT
  987.      DISPLAY
  988.  
  989. SEE ALSO
  990.      SET DISPLAY, SET SELECT, ALL
  991.  
  992. STATUS
  993.      Completed.
  994. **man-end**********************************************************************/
  995. #ifdef PROTO
  996. short Scope(CHARTYPE *params)
  997. #else
  998. short Scope(params)
  999. CHARTYPE *params;
  1000. #endif
  1001. /***********************************************************************/
  1002. {
  1003. /*-------------------------- external data ----------------------------*/
  1004. /*--------------------------- local data ------------------------------*/
  1005.  short rc=RC_OK;
  1006. /*--------------------------- processing ------------------------------*/
  1007. #ifdef TRACE
  1008.  trace_function("commset2.c:Scope");
  1009. #endif
  1010.  if (equal("all",params,1))
  1011.     CURRENT_VIEW->scope_all = TRUE;
  1012.  else
  1013.     if (equal("display",params,1))
  1014.        CURRENT_VIEW->scope_all = FALSE;
  1015.     else
  1016.       {
  1017.        display_error(1,params,FALSE);
  1018. #ifdef TRACE
  1019.        trace_return();
  1020. #endif
  1021.        return(RC_INVALID_OPERAND);
  1022.       }
  1023. #ifdef TRACE
  1024.  trace_return();
  1025. #endif
  1026.  return(rc);
  1027. }
  1028. /*man-start*********************************************************************
  1029. COMMAND
  1030.      screen - specifiy number of screens displayed
  1031.  
  1032. SYNTAX
  1033.      [SET] SCReen n [Horizontal|Vertical]
  1034.  
  1035. DESCRIPTION
  1036.      The SCREEN command specifies the number of views of file(s) to
  1037.      display on screen at once. If the number of views specified is 2
  1038.      and only one file is currently in the ring, two views of the
  1039.      same file are displayed.
  1040.  
  1041. COMPATIBILITY
  1042.      XEDIT: Does not support Size,Width or Define options.
  1043.      KEDIT: Does not support Size option.
  1044.      Only 2 screens are supported.
  1045.  
  1046. DEFAULT
  1047.      1
  1048.  
  1049. STATUS
  1050.      Complete.
  1051. **man-end**********************************************************************/
  1052. #ifdef PROTO
  1053. short THEScreen(CHARTYPE *params)
  1054. #else
  1055. short THEScreen(params)
  1056. CHARTYPE *params;
  1057. #endif
  1058. /***********************************************************************/
  1059. {
  1060. /*-------------------------- external data ----------------------------*/
  1061.  extern WINDOW *divider;
  1062.  extern VIEW_DETAILS *vd_first;
  1063.  extern CHARTYPE number_of_views;
  1064.  extern CHARTYPE display_screens;
  1065.  extern bool horizontal;
  1066.  extern bool curses_started;
  1067. /*--------------------------- local data ------------------------------*/
  1068. #define SCR_PARAMS  2
  1069.  CHARTYPE *word[SCR_PARAMS+1];
  1070.  register short i=0;
  1071.  unsigned short num_params=0,num_views=0;
  1072.  CHARTYPE save_display_screens=0;
  1073.  bool save_horizontal=FALSE;
  1074.  int horiz=(-1);
  1075.  VIEW_DETAILS *save_current_view=NULL;
  1076.  CHARTYPE save_current_screen=0;
  1077.  short rc=RC_OK;
  1078. /*--------------------------- processing ------------------------------*/
  1079. #ifdef TRACE
  1080.  trace_function("commset2.c:THEScreen");
  1081. #endif
  1082.  num_params = param_split(params,word,SCR_PARAMS,WORD_DELIMS,TEMP_PARAM);
  1083.  if (!valid_positive_integer(word[0]))
  1084.    {
  1085.     display_error(1,word[0],FALSE);
  1086. #ifdef TRACE
  1087.     trace_return();
  1088. #endif
  1089.     return(RC_INVALID_OPERAND);
  1090.    }
  1091.  if ((num_views = atoi(word[0])) > MAX_SCREENS)
  1092.    {
  1093.     display_error(6,word[0],FALSE);
  1094. #ifdef TRACE
  1095.     trace_return();
  1096. #endif
  1097.     return(RC_INVALID_OPERAND);
  1098.    }
  1099.  if (num_views == 1)
  1100.     horiz = TRUE;
  1101.  else
  1102.    {
  1103.     if (equal((CHARTYPE *)"horizontal",word[1],1)
  1104.     || strcmp(word[1],"") == 0)
  1105.        horiz = TRUE;
  1106.     if (equal((CHARTYPE *)"vertical",word[1],1))
  1107.        horiz = FALSE;
  1108.     if (horiz == (-1))
  1109.       {
  1110.        display_error(1,word[1],FALSE);
  1111. #ifdef TRACE
  1112.        trace_return();
  1113. #endif
  1114.        return(RC_INVALID_OPERAND);
  1115.       }
  1116.    }
  1117. /*---------------------------------------------------------------------*/
  1118. /* Set the global variable display_screens to indicate the number of   */
  1119. /* screens currently displayed and the orientation of those screens    */
  1120. /* Save the old values first so we know how the screens were oriented. */
  1121. /*---------------------------------------------------------------------*/
  1122.  save_display_screens = display_screens;
  1123.  save_horizontal = horizontal;
  1124.  
  1125.  display_screens = (CHARTYPE)num_views;
  1126.  horizontal=(bool)horiz;
  1127. /*---------------------------------------------------------------------*/
  1128. /* If there is no change to the screens, exit.                         */
  1129. /*---------------------------------------------------------------------*/
  1130.  if (display_screens == save_display_screens
  1131.  &&  horizontal == save_horizontal)
  1132.    {
  1133. #ifdef TRACE
  1134.     trace_return();
  1135. #endif
  1136.     return(RC_OK);
  1137.    }
  1138.  post_process_line(CURRENT_VIEW,CURRENT_VIEW->focus_line);
  1139. /*---------------------------------------------------------------------*/
  1140. /* Save the screen coordinates for later retrieval.                    */
  1141. /*---------------------------------------------------------------------*/
  1142.  if (curses_started)
  1143.    {
  1144.     getyx(CURRENT_WINDOW_MAIN,CURRENT_VIEW->y[WINDOW_MAIN],CURRENT_VIEW->x[WINDOW_MAIN]);
  1145.     if (CURRENT_WINDOW_PREFIX != NULL)
  1146.        getyx(CURRENT_WINDOW_PREFIX,CURRENT_VIEW->y[WINDOW_PREFIX],CURRENT_VIEW->x[WINDOW_PREFIX]);
  1147.    }
  1148. /*---------------------------------------------------------------------*/
  1149. /* Set up the screen views correctly so that when we create the new    */
  1150. /* window for each screen, the screens have a view to point to...      */
  1151. /*---------------------------------------------------------------------*/
  1152.  switch(display_screens)
  1153.    {
  1154.     case 1:                         /* now have only 1 screen (from 2) */
  1155.            save_current_view = CURRENT_VIEW;
  1156.            if (CURRENT_SCREEN.screen_view->file_for_view == OTHER_SCREEN.screen_view->file_for_view)
  1157.              {
  1158.               CURRENT_VIEW = OTHER_SCREEN.screen_view;
  1159.               CURRENT_FILE->file_views--;
  1160.               free_a_view();
  1161.               CURRENT_VIEW = save_current_view;
  1162.              }
  1163.            if (divider == (WINDOW *)NULL)
  1164.              {
  1165.               delwin(divider);
  1166.               divider = NULL;
  1167.              }
  1168.            current_screen = 0;
  1169.            CURRENT_SCREEN.screen_view = CURRENT_VIEW = save_current_view;
  1170.            OTHER_SCREEN.screen_view = NULL;
  1171.            break;
  1172.     case 2:                             /* now have 2 screens (from 1) */
  1173.            save_current_view = CURRENT_VIEW;
  1174.            save_current_screen = current_screen;
  1175.            current_screen = (current_screen==0)?1:0; /* make other screen current */
  1176.            if (number_of_views == 1)
  1177.              {
  1178.               if ((rc = defaults_for_other_files(TRUE)) != RC_OK)
  1179.                 {
  1180. #ifdef TRACE
  1181.                  trace_return();
  1182. #endif
  1183.                  return(rc);
  1184.                 }
  1185.               CURRENT_FILE = save_current_view->file_for_view;
  1186.               CURRENT_FILE->file_views++;
  1187.              }
  1188.            else
  1189.              {
  1190.               if (NEXT_VIEW == (VIEW_DETAILS *)NULL)
  1191.                  CURRENT_VIEW = vd_first;
  1192.               else
  1193.                  CURRENT_VIEW = NEXT_VIEW;
  1194.              }
  1195.            CURRENT_SCREEN.screen_view = CURRENT_VIEW;
  1196.            CURRENT_VIEW = save_current_view;
  1197.            current_screen = save_current_screen;
  1198.            break;
  1199.    }
  1200.  
  1201.  set_screen_defaults();
  1202.  if (curses_started)
  1203.    {
  1204.     for (i=0;i<display_screens;i++)
  1205.       {
  1206.        if ((rc = set_up_windows(i)) != RC_OK)
  1207.          {
  1208. #ifdef TRACE
  1209.           trace_return();
  1210. #endif
  1211.           return(rc);
  1212.          }
  1213.        if (screen[i].screen_view->prefix)
  1214.           wmove(screen[i].win[WINDOW_PREFIX],
  1215.                 screen[i].screen_view->y[WINDOW_PREFIX],screen[i].screen_view->x[WINDOW_PREFIX]);
  1216.        wmove(screen[i].win[WINDOW_MAIN],
  1217.              screen[i].screen_view->y[WINDOW_MAIN],screen[i].screen_view->x[WINDOW_MAIN]);
  1218.       }
  1219.    }
  1220.  
  1221.  if (!horizontal
  1222.  && display_screens > 1
  1223.  && curses_started)
  1224.    {
  1225.     redraw_window(divider);
  1226.     touchwin(divider);
  1227.     wnoutrefresh(divider);
  1228.    }
  1229.  
  1230.  if (display_screens > 1)
  1231.    {
  1232.     pre_process_line(OTHER_SCREEN.screen_view,OTHER_SCREEN.screen_view->focus_line);
  1233.     build_other_screen();
  1234.     display_other_screen();
  1235.    }
  1236.  pre_process_line(CURRENT_VIEW,CURRENT_VIEW->focus_line);
  1237.  build_current_screen();
  1238.  display_current_screen();
  1239.  
  1240. #ifdef TRACE
  1241.  trace_return();
  1242. #endif
  1243.  return(RC_OK);
  1244. }
  1245. /*man-start*********************************************************************
  1246. COMMAND
  1247.      select - sets the selection level for the specified lines
  1248.  
  1249. SYNTAX
  1250.      [SET] SELect [+|-]n [target]
  1251.  
  1252. DESCRIPTION
  1253.      The SELECT command sets the selection level for the indicated
  1254.      lines equal to n (if no signs are specified) or adds or subtracts
  1255.      n from the selection level currently set for the lines in the
  1256.      target.
  1257.  
  1258. COMPATIBILITY
  1259.      XEDIT: Compatible.
  1260.      KEDIT: Compatible.
  1261.  
  1262. DEFAULT
  1263.      0
  1264.  
  1265. SEE ALSO
  1266.      SET SCOPE, SET DISPLAY, ALL
  1267.  
  1268. STATUS
  1269.      Complete.
  1270. **man-end**********************************************************************/
  1271. #ifdef PROTO
  1272. short Select(CHARTYPE *params)
  1273. #else
  1274. short Select(params)
  1275. CHARTYPE *params;
  1276. #endif
  1277. /***********************************************************************/
  1278. {
  1279. /*-------------------------- external data ----------------------------*/
  1280. /*--------------------------- local data ------------------------------*/
  1281.  short rc=RC_OK;
  1282. #define SEL_PARAMS  2
  1283.  CHARTYPE *word[SEL_PARAMS+1];
  1284.  LINETYPE num_lines,true_line,i;
  1285.  short num_params=0;
  1286.  bool relative=FALSE;
  1287.  short direction=0;
  1288.  short off=0;
  1289.  LINE *curr=NULL;
  1290.  short target_type=TARGET_NORMAL|TARGET_BLOCK_CURRENT|TARGET_ALL;
  1291.  TARGET target;
  1292. /*--------------------------- processing ------------------------------*/
  1293. #ifdef TRACE
  1294.  trace_function("commset2.c:Select");
  1295. #endif
  1296.  num_params = param_split(params,word,SEL_PARAMS,WORD_DELIMS,TEMP_PARAM);
  1297.  if (num_params < 1)
  1298.    {
  1299.     display_error(3,(CHARTYPE *)"",FALSE);
  1300. #ifdef TRACE
  1301.     trace_return();
  1302. #endif
  1303.     return(RC_INVALID_OPERAND);
  1304.    }
  1305. /*---------------------------------------------------------------------*/
  1306. /* Parse the first parameter...                                        */
  1307. /*---------------------------------------------------------------------*/
  1308. /* Determine if the selection level is relative to the existing value  */
  1309. /* or is an absolute value.                                            */
  1310. /*---------------------------------------------------------------------*/
  1311.  if (*(word[0]) == '-'
  1312.  ||  *(word[0]) == '+')
  1313.     relative = TRUE;
  1314.  else
  1315.     relative = FALSE;
  1316. /*---------------------------------------------------------------------*/
  1317. /* Get the value, positive or negative.                                */
  1318. /*---------------------------------------------------------------------*/
  1319.  if (!valid_integer(word[0]))
  1320.    {
  1321.     display_error(1,word[0],FALSE);
  1322. #ifdef TRACE
  1323.     trace_return();
  1324. #endif
  1325.     return(RC_INVALID_OPERAND);
  1326.    }
  1327.  off = atoi(word[0]);
  1328. /*---------------------------------------------------------------------*/
  1329. /* Parse the next parameter...                                         */
  1330. /*---------------------------------------------------------------------*/
  1331.  true_line = get_true_line();
  1332. /*---------------------------------------------------------------------*/
  1333. /* If no target specified, just apply to the current line...           */
  1334. /*---------------------------------------------------------------------*/
  1335.  if (num_params == 1)
  1336.     word[1] = (CHARTYPE *)"1";
  1337.  initialise_target(&target);
  1338.  if ((rc = validate_target(word[1],&target,target_type,get_true_line(),TRUE,TRUE)) != RC_OK)
  1339.    {
  1340.     free_target(&target);
  1341. #ifdef TRACE
  1342.     trace_return();
  1343. #endif
  1344.     return(rc);
  1345.    }
  1346.  num_lines = target.num_lines;
  1347.  true_line = target.true_line;
  1348.  direction = (target.num_lines<0) ? DIRECTION_BACKWARD : DIRECTION_FORWARD;
  1349.  free_target(&target);
  1350.  post_process_line(CURRENT_VIEW,CURRENT_VIEW->focus_line);
  1351. /*---------------------------------------------------------------------*/
  1352. /* Get the current line from which to begin changing the select level. */
  1353. /*---------------------------------------------------------------------*/
  1354.  curr = lll_find(CURRENT_FILE->first_line,true_line);
  1355. /*---------------------------------------------------------------------*/
  1356. /* For the number of lines affected, change the select level if the    */
  1357. /* line is in scope.                                                   */
  1358. /*---------------------------------------------------------------------*/
  1359.  for (i=0;i<num_lines;i++)
  1360.    {
  1361.     if (in_scope(curr) || CURRENT_VIEW->scope_all)
  1362.       {
  1363.        if (relative)
  1364.          {
  1365.           if (((short)curr->select + off) > 255)
  1366.              curr->select = 255;
  1367.           else
  1368.              if (((short)curr->select + off) < 0)
  1369.                 curr->select = 0;
  1370.              else
  1371.                 curr->select = off;
  1372.          }
  1373.        else
  1374.           curr->select = off;
  1375.       }
  1376.     if (direction == DIRECTION_FORWARD)
  1377.        curr = curr->next;
  1378.     else
  1379.        curr = curr->prev;
  1380.    }
  1381. /*---------------------------------------------------------------------*/
  1382. /* If we are on the command line and the result of this statement means*/
  1383. /* that the current line is no longer in scope, we need to make the    */
  1384. /* current line and possibly the focus line the next line in scope.    */
  1385. /*---------------------------------------------------------------------*/
  1386.  if (CURRENT_VIEW->current_window == WINDOW_COMMAND)
  1387.    {
  1388.     CURRENT_VIEW->current_line = find_next_in_scope(NULL,true_line,DIRECTION_FORWARD);
  1389.     build_current_screen();
  1390.     if (!line_in_view(CURRENT_VIEW->focus_line))
  1391.       {
  1392.        CURRENT_VIEW->focus_line = CURRENT_VIEW->current_line;
  1393.        pre_process_line(CURRENT_VIEW,CURRENT_VIEW->focus_line);
  1394.       }
  1395.    }
  1396.  pre_process_line(CURRENT_VIEW,CURRENT_VIEW->focus_line);
  1397.  build_current_screen();
  1398.  display_current_screen();
  1399.  
  1400. #ifdef TRACE
  1401.  trace_return();
  1402. #endif
  1403.  return(rc);
  1404. }
  1405. /*man-start*********************************************************************
  1406. COMMAND
  1407.      shadow - determines if shadow lines are displayed or not
  1408.  
  1409. SYNTAX
  1410.      [SET] SHADOW ON|OFF
  1411.  
  1412. DESCRIPTION
  1413.      The SHADOW command indicates whether shadow lines are to be
  1414.      displayed.
  1415.  
  1416. COMPATIBILITY
  1417.      XEDIT: Compatible.
  1418.      KEDIT: Compatible.
  1419.  
  1420. DEFAULT
  1421.      ON
  1422.  
  1423. SEE ALSO
  1424.      SET DISPLAY, SET SELECT, ALL
  1425.  
  1426. STATUS
  1427.      Completed.
  1428. **man-end**********************************************************************/
  1429. #ifdef PROTO
  1430. short Shadow(CHARTYPE *params)
  1431. #else
  1432. short Shadow(params)
  1433. CHARTYPE *params;
  1434. #endif
  1435. /***********************************************************************/
  1436. {
  1437. /*-------------------------- external data ----------------------------*/
  1438. /*--------------------------- local data ------------------------------*/
  1439.  short rc=RC_OK;
  1440. /*--------------------------- processing ------------------------------*/
  1441. #ifdef TRACE
  1442.  trace_function("commset2.c:Shadow");
  1443. #endif
  1444.  rc = execute_set_on_off(params,&CURRENT_VIEW->shadow);
  1445.  if (rc == RC_OK)
  1446.    {
  1447.     build_current_screen();
  1448.     display_current_screen();
  1449.    }
  1450. #ifdef TRACE
  1451.  trace_return();
  1452. #endif
  1453.  return(rc);
  1454. }
  1455. /*man-start*********************************************************************
  1456. COMMAND
  1457.      statusline - set position of status line
  1458.  
  1459. SYNTAX
  1460.      [SET] STATUSLine Top|Bottom|Off|GUI
  1461.  
  1462. DESCRIPTION
  1463.  
  1464.      The STATUSLINE command determines the position of the status
  1465.      line for the editing session. TOP will place the status line on
  1466.      the first line of the screen; BOTTOM will place the status line
  1467.      on the last line of the screen; OFF turns off the display of
  1468.      the status line.
  1469.  
  1470.      The GUI option is only meaningful for those platforms that support
  1471.      a separate status line window. If specified for non-GUI ports, the
  1472.      GUI option is equivalent to OFF.
  1473.  
  1474. COMPATIBILITY
  1475.      XEDIT: N/A
  1476.      KEDIT: Compatible.
  1477.             Added GUI option.
  1478.  
  1479. DEFAULT
  1480.      BOTTOM
  1481.  
  1482. STATUS
  1483.      Complete
  1484. **man-end**********************************************************************/
  1485. #ifdef PROTO
  1486. short Statusline(CHARTYPE *params)
  1487. #else
  1488. short Statusline(params)
  1489. CHARTYPE *params;
  1490. #endif
  1491. /***********************************************************************/
  1492. {
  1493. /*-------------------------- external data ----------------------------*/
  1494.  extern ROWTYPE STATUSLINEx;
  1495.  extern CHARTYPE display_screens;
  1496.  extern bool curses_started;
  1497.  extern bool horizontal;
  1498.  extern WINDOW *divider;
  1499. /*--------------------------- local data ------------------------------*/
  1500.  CHARTYPE stat_place='?';
  1501.  short rc=RC_OK;
  1502. /*--------------------------- processing ------------------------------*/
  1503. #ifdef TRACE
  1504.  trace_function("commset2.c:Statusline");
  1505. #endif
  1506.  if (equal((CHARTYPE *)"top",params,1))
  1507.     stat_place='T';
  1508.  if (equal((CHARTYPE *)"bottom",params,1))
  1509.     stat_place='B';
  1510.  if (equal((CHARTYPE *)"off",params,2))
  1511.     stat_place='O';
  1512.  if (equal((CHARTYPE *)"gui",params,3))
  1513.    {
  1514.     stat_place='G';
  1515. #ifdef MSWIN
  1516.     SetStatusBar(1);
  1517. #endif
  1518.    }
  1519. #ifdef MSWIN
  1520.  else
  1521.    {
  1522.     SetStatusBar(0);
  1523.    }
  1524. #endif
  1525.  if (stat_place=='?')
  1526.    {
  1527.     display_error(1,(CHARTYPE *)params,FALSE);
  1528. #ifdef TRACE
  1529.     trace_return();
  1530. #endif
  1531.     return(RC_INVALID_OPERAND);
  1532.    }
  1533. /*---------------------------------------------------------------------*/
  1534. /* If the setting supplied is the same as the current setting, just    */
  1535. /* return without doing anything.                                      */
  1536. /*---------------------------------------------------------------------*/
  1537.  if (stat_place == STATUSLINEx)
  1538.    {
  1539. #ifdef TRACE
  1540.     trace_return();
  1541. #endif
  1542.     return(RC_OK);
  1543.    }
  1544. /*---------------------------------------------------------------------*/
  1545. /* Now we need to move the windows around.                             */
  1546. /*---------------------------------------------------------------------*/
  1547.  STATUSLINEx = stat_place;
  1548. /*---------------------------------------------------------------------*/
  1549. /* Redefine the screen sizes and recreate statusline window...         */
  1550. /*---------------------------------------------------------------------*/
  1551.  set_screen_defaults();
  1552.  if (curses_started)
  1553.    {
  1554.     if (create_statusline_window() != RC_OK)
  1555.       {
  1556. #ifdef TRACE
  1557.        trace_return();
  1558. #endif
  1559.        return(rc);
  1560.       }
  1561.    }
  1562. /*---------------------------------------------------------------------*/
  1563. /* Recreate windows for other screen (if there is one)...              */
  1564. /*---------------------------------------------------------------------*/
  1565.  if (display_screens > 1)
  1566.    {
  1567.     if (curses_started)
  1568.       {
  1569.        if (set_up_windows((current_screen==0) ? 1 : 0) != RC_OK)
  1570.          {
  1571. #ifdef TRACE
  1572.           trace_return();
  1573. #endif
  1574.           return(rc);
  1575.          }
  1576.        if (!horizontal)
  1577.          {
  1578.           redraw_window(divider);
  1579.           touchwin(divider);
  1580.           wnoutrefresh(divider);
  1581.          }
  1582.       }
  1583.     build_other_screen();
  1584.     display_other_screen();
  1585.    }
  1586. /*---------------------------------------------------------------------*/
  1587. /* Recreate windows for the current screen...                          */
  1588. /*---------------------------------------------------------------------*/
  1589.  if (curses_started)
  1590.    {
  1591.     if (set_up_windows(current_screen) != RC_OK)
  1592.       {
  1593. #ifdef TRACE
  1594.        trace_return();
  1595. #endif
  1596.        return(rc);
  1597.       }
  1598.    }
  1599.  build_current_screen();
  1600.  display_current_screen();
  1601. #ifdef TRACE
  1602.  trace_return();
  1603. #endif
  1604.  return(rc);
  1605. }
  1606. /*man-start*********************************************************************
  1607. COMMAND
  1608.      stay - set condition of cursor position after CHANGE/LOCATE commands
  1609.  
  1610. SYNTAX
  1611.      [SET] STAY ON|OFF
  1612.  
  1613. DESCRIPTION
  1614.      The STAY set command determines what line is displayed as the current
  1615.      line after an unsuccessful LOCATE or successful CHANGE command.
  1616.      With STAY ON, the current line remains where it currently is. With
  1617.      STAY OFF, after an unsuccessful LOCATE, the current line is "Bottom
  1618.      of File". After a successful CHANGE, the current line is the last
  1619.      line affected by the CHANGE command.
  1620.  
  1621. COMPATIBILITY
  1622.      XEDIT: Compatible.
  1623.      KEDIT: Compatible.
  1624.  
  1625. DEFAULT
  1626.      ON
  1627.  
  1628. STATUS
  1629.      Complete
  1630. **man-end**********************************************************************/
  1631. #ifdef PROTO
  1632. short Stay(CHARTYPE *params)
  1633. #else
  1634. short Stay(params)
  1635. CHARTYPE *params;
  1636. #endif
  1637. /***********************************************************************/
  1638. {
  1639. /*-------------------------- external data ----------------------------*/
  1640. /*--------------------------- local data ------------------------------*/
  1641.  short rc=RC_OK;
  1642. /*--------------------------- processing ------------------------------*/
  1643. #ifdef TRACE
  1644.  trace_function("commset2.c:Stay");
  1645. #endif
  1646.  rc = execute_set_on_off(params,&CURRENT_VIEW->stay);
  1647. #ifdef TRACE
  1648.  trace_return();
  1649. #endif
  1650.  return(rc);
  1651. }
  1652. /*man-start*********************************************************************
  1653. COMMAND
  1654.      synonym - define synonyms for commands
  1655.  
  1656. SYNTAX
  1657.      [SET] SYNonym ON|OFF
  1658.      [SET] SYNonym [LINEND char] newname [n] oldname
  1659.  
  1660. DESCRIPTION
  1661.      The SYNONYM command allows the user to define synonyms for commands
  1662.      or macros.
  1663.  
  1664.      The first format indicates if synonym processing is to be performed.
  1665.  
  1666.      The second format specifies the name to be associated with the
  1667.      following commands.
  1668.  
  1669. COMPATIBILITY
  1670.      XEDIT: Does not support the formatting option.
  1671.      KEDIT: Compatible.
  1672.  
  1673. DEFAULT
  1674.      ON
  1675.  
  1676. STATUS
  1677.      Incomplete.
  1678. **man-end**********************************************************************/
  1679. #ifdef PROTO
  1680. short Synonym(CHARTYPE *params)
  1681. #else
  1682. short Synonym(params)
  1683. CHARTYPE *params;
  1684. #endif
  1685. /***********************************************************************/
  1686. {
  1687. /*--------------------------- local data ------------------------------*/
  1688.  short rc=RC_OK;
  1689. /*--------------------------- processing ------------------------------*/
  1690. #ifdef TRACE
  1691.  trace_function("commset2.c:Synonym");
  1692. #endif
  1693.  display_error(0,"This command not yet implemented",FALSE);
  1694. /*---------------------------------------------------------------------*/
  1695. /* Do not allow the command COMMAND to be synonymed.                   */
  1696. /*---------------------------------------------------------------------*/
  1697. #ifdef TRACE
  1698.  trace_return();
  1699. #endif
  1700.  return(rc);
  1701. }
  1702. /*man-start*********************************************************************
  1703. COMMAND
  1704.      tabkey - set characteristics of the SOS TABF command
  1705.  
  1706. SYNTAX
  1707.      [SET] TABKey Tab|Character Tab|Character
  1708.  
  1709. DESCRIPTION
  1710.      The TABKEY sets the action to be taken when the SOS TABF command
  1711.      is executed. Depending on the insert mode, the SOS TABF command
  1712.      will either display a raw tab character or will move to the next
  1713.      tab column.
  1714.      The first operand refers to the behaviour of the SOS TABF command
  1715.      when INSERTMODE is OFF; the second operand specifies the behaviour
  1716.      when the SOS TABF command is executed when INSERTMODE is ON.
  1717.  
  1718. COMPATIBILITY
  1719.      XEDIT: N/A
  1720.      KEDIT: N/A
  1721.  
  1722. DEFAULT
  1723.      TAB CHARACTER
  1724.  
  1725. STATUS
  1726.      Complete
  1727. **man-end**********************************************************************/
  1728. #ifdef PROTO
  1729. short Tabkey(CHARTYPE *params)
  1730. #else
  1731. short Tabkey(params)
  1732. CHARTYPE *params;
  1733. #endif
  1734. /***********************************************************************/
  1735. {
  1736. /*-------------------------- external data ----------------------------*/
  1737.  extern CHARTYPE tabkey_insert,tabkey_overwrite;
  1738. /*--------------------------- local data ------------------------------*/
  1739. #define TKY_PARAMS  3
  1740.  CHARTYPE *word[TKY_PARAMS+1];
  1741.  unsigned short num_params=0;
  1742.  CHARTYPE tabo=tabkey_overwrite;
  1743.  CHARTYPE tabi=tabkey_insert;
  1744.  short rc=RC_INVALID_OPERAND;
  1745. /*--------------------------- processing ------------------------------*/
  1746. #ifdef TRACE
  1747.  trace_function("commset2.c:Tabkey");
  1748. #endif
  1749. /*---------------------------------------------------------------------*/
  1750. /* Validate the parameters that have been supplied.                    */
  1751. /*---------------------------------------------------------------------*/
  1752.  num_params = param_split(params,word,TKY_PARAMS,WORD_DELIMS,TEMP_PARAM);
  1753.  switch(num_params)
  1754.    {
  1755. /*---------------------------------------------------------------------*/
  1756. /* Too few parameters, error.                                          */
  1757. /*---------------------------------------------------------------------*/
  1758.     case 0:
  1759.     case 1:
  1760.          display_error(3,(CHARTYPE *)"",FALSE);
  1761.          break;
  1762. /*---------------------------------------------------------------------*/
  1763. /* 2 parameters, validate them...                                      */
  1764. /*---------------------------------------------------------------------*/
  1765.     case 2:
  1766. /*---------------------------------------------------------------------*/
  1767. /* Validate first parameter; overwrite mode setting...                 */
  1768. /*---------------------------------------------------------------------*/
  1769.          if (equal((CHARTYPE *)"character",word[0],1))
  1770.            {
  1771.             tabo = 'C';
  1772.             rc = RC_OK;
  1773.            }
  1774.          if (equal((CHARTYPE *)"tab",word[0],1))
  1775.            {
  1776.             tabo = 'T';
  1777.             rc = RC_OK;
  1778.            }
  1779. /*---------------------------------------------------------------------*/
  1780. /* If not a valid first parameter, display an error and exit.          */
  1781. /*---------------------------------------------------------------------*/
  1782.          if (rc != RC_OK)
  1783.            {
  1784.             display_error(1,word[0],FALSE);
  1785.             break;
  1786.            }
  1787.          rc = RC_INVALID_OPERAND;
  1788. /*---------------------------------------------------------------------*/
  1789. /* Validate second parameter; insert mode setting...                   */
  1790. /*---------------------------------------------------------------------*/
  1791.          if (equal((CHARTYPE *)"character",word[1],1))
  1792.            {
  1793.             tabi = 'C';
  1794.             rc = RC_OK;
  1795.            }
  1796. /*---------------------------------------------------------------------*/
  1797. /* Validate second parameter; insert mode setting...                   */
  1798. /*---------------------------------------------------------------------*/
  1799.          if (equal((CHARTYPE *)"tab",word[1],1))
  1800.            {
  1801.             tabi = 'T';
  1802.             rc = RC_OK;
  1803.            }
  1804. /*---------------------------------------------------------------------*/
  1805. /* If not a valid second parameter, display an error and exit.         */
  1806. /*---------------------------------------------------------------------*/
  1807.          if (rc != RC_OK)
  1808.            {
  1809.             display_error(1,word[1],FALSE);
  1810.             break;
  1811.            }
  1812.          rc = RC_OK;
  1813.          break;
  1814. /*---------------------------------------------------------------------*/
  1815. /* Too many parameters...                                              */
  1816. /*---------------------------------------------------------------------*/
  1817.     default:
  1818.          display_error(2,(CHARTYPE *)"",FALSE);
  1819.          break;
  1820.    }
  1821. /*---------------------------------------------------------------------*/
  1822. /* If valid parameters, change the settings...                         */
  1823. /*---------------------------------------------------------------------*/
  1824.  if (rc == RC_OK)
  1825.    {
  1826.     tabkey_insert = tabi;
  1827.     tabkey_overwrite = tabo;
  1828.    }
  1829. #ifdef TRACE
  1830.  trace_return();
  1831. #endif
  1832.  return(RC_OK);
  1833. }
  1834. /*man-start*********************************************************************
  1835. COMMAND
  1836.      tabline - set position and status of tab line on screen
  1837.  
  1838. SYNTAX
  1839.      [SET] TABLine ON|OFF [M[+n|-n]|[+|-]n]
  1840.  
  1841. DESCRIPTION
  1842.      The TABLINE command sets the position and status of the tab line
  1843.      for the current view.
  1844.  
  1845.      The two forms of the position parameters are:
  1846.      M[+n|-n] - this sets the tab line to be relative to the
  1847.                 middle of the screen. A positive value adds to the
  1848.                 middle line number, a negative subtracts from it.
  1849.                 eg. M+3 on a 24 line screen will be line 15
  1850.                     M-5 on a 24 line screen will be line 7
  1851.  
  1852.      [+|-]n   - this sets the tab line to be relative to the
  1853.                 top of the screen (if positive or no sign) or
  1854.                 relative to the bottom of the screen if negative.
  1855.                 eg. +3 or 3 will set tab line to line 3
  1856.                     -3 on a 24 line screen will be line 21
  1857.  
  1858.      If the resulting line is outside the bounds of the screen
  1859.      the position of the current line will become the middle line
  1860.      on the screen.
  1861.  
  1862. COMPATIBILITY
  1863.      XEDIT: Compatible.
  1864.      KEDIT: Compatible.
  1865.  
  1866. DEFAULT
  1867.      OFF -3
  1868.  
  1869. STATUS
  1870.      Complete.
  1871. **man-end**********************************************************************/
  1872. #ifdef PROTO
  1873. short Tabline(CHARTYPE *params)
  1874. #else
  1875. short Tabline(params)
  1876. CHARTYPE *params;
  1877. #endif
  1878. /***********************************************************************/
  1879. {
  1880. /*-------------------------- external data ----------------------------*/
  1881. /*--------------------------- local data ------------------------------*/
  1882. #define TBL_PARAMS  2
  1883.  CHARTYPE *word[TBL_PARAMS+1];
  1884.  short num_params=0;
  1885.  short rc=RC_OK;
  1886.  short base=(short)CURRENT_VIEW->tab_base;
  1887.  short off=CURRENT_VIEW->tab_off;
  1888.  bool tabsts=FALSE;
  1889. /*--------------------------- processing ------------------------------*/
  1890. #ifdef TRACE
  1891.  trace_function("commset2.c:Tabline");
  1892. #endif
  1893.  num_params = param_split(params,word,TBL_PARAMS,WORD_DELIMS,TEMP_PARAM);
  1894.  if (num_params < 1)
  1895.    {
  1896.     display_error(3,(CHARTYPE *)"",FALSE);
  1897. #ifdef TRACE
  1898.     trace_return();
  1899. #endif
  1900.     return(RC_INVALID_OPERAND);
  1901.    }
  1902. /*---------------------------------------------------------------------*/
  1903. /* Parse the status parameter...                                       */
  1904. /*---------------------------------------------------------------------*/
  1905.  rc = execute_set_on_off(word[0],&tabsts);
  1906.  if (rc != RC_OK)
  1907.    {
  1908. #ifdef TRACE
  1909.     trace_return();
  1910. #endif
  1911.     return(rc);
  1912.    }
  1913. /*---------------------------------------------------------------------*/
  1914. /* Parse the position parameter...                                     */
  1915. /*---------------------------------------------------------------------*/
  1916.  if (num_params > 1)
  1917.    {
  1918.     rc = execute_set_row_position(word[1],&base,&off);
  1919.     if (rc != RC_OK)
  1920.       {
  1921. #ifdef TRACE
  1922.        trace_return();
  1923. #endif
  1924.        return(rc);
  1925.       }
  1926.    }
  1927.  CURRENT_VIEW->tab_base = (CHARTYPE)base;
  1928.  CURRENT_VIEW->tab_off = off;
  1929.  CURRENT_VIEW->tab_on = tabsts;
  1930.  post_process_line(CURRENT_VIEW,CURRENT_VIEW->focus_line);
  1931.  build_current_screen();
  1932.  display_current_screen();
  1933. #ifdef TRACE
  1934.  trace_return();
  1935. #endif
  1936.  return(RC_OK);
  1937. }
  1938. /*man-start*********************************************************************
  1939. COMMAND
  1940.      tabs - set tab length for TAB key
  1941.  
  1942. SYNTAX
  1943.      [SET] TABS n1 n2[n3...n32]
  1944.      [SET] TABS INCR n
  1945.  
  1946. DESCRIPTION
  1947.      The TABS command determines the position of tab columns when the
  1948.      SOS TABF or SOS TABB commands are executed.
  1949.  
  1950. COMPATIBILITY
  1951.      XEDIT: Compatible.
  1952.      KEDIT: Compatible.
  1953.  
  1954. DEFAULT
  1955.      INCR 8
  1956.  
  1957. SEE ALSO
  1958.      SOS TABF, SOS TABB
  1959.  
  1960. STATUS
  1961.      Complete.
  1962. **man-end**********************************************************************/
  1963. #ifdef PROTO
  1964. short Tabs(CHARTYPE *params)
  1965. #else
  1966. short Tabs(params)
  1967. CHARTYPE *params;
  1968. #endif
  1969. /***********************************************************************/
  1970. {
  1971. /*-------------------------- external data ----------------------------*/
  1972. /*--------------------------- local data ------------------------------*/
  1973. #define TABS_PARAMS  MAX_NUMTABS
  1974.  CHARTYPE *word[TABS_PARAMS+1];
  1975.  LENGTHTYPE stops[TABS_PARAMS];
  1976.  register short i=0;
  1977.  unsigned short num_params=0;
  1978.  LENGTHTYPE tabinc=0;
  1979. /*--------------------------- processing ------------------------------*/
  1980. #ifdef TRACE
  1981.  trace_function("commset2.c:Tabs");
  1982. #endif
  1983.  num_params = param_split(params,word,TABS_PARAMS,WORD_DELIMS,TEMP_PARAM);
  1984. /*---------------------------------------------------------------------*/
  1985. /* If the INCR option is specified...                                  */
  1986. /*---------------------------------------------------------------------*/
  1987.  if (equal((CHARTYPE *)"incr",word[0],2))
  1988.    {
  1989.     if (num_params != 2)
  1990.       {
  1991.        display_error(2,(CHARTYPE *)"",FALSE);
  1992. #ifdef TRACE
  1993.        trace_return();
  1994. #endif
  1995.        return(RC_INVALID_OPERAND);
  1996.       }
  1997.     if (!valid_positive_integer(word[1]))
  1998.       {
  1999.        display_error(4,word[1],FALSE);
  2000. #ifdef TRACE
  2001.        trace_return();
  2002. #endif
  2003.        return(RC_INVALID_OPERAND);
  2004.       }
  2005.     tabinc = (LENGTHTYPE)atoi(word[1]);
  2006.     if (tabinc < 1)
  2007.       {
  2008.        display_error(5,word[1],FALSE);
  2009. #ifdef TRACE
  2010.        trace_return();
  2011. #endif
  2012.        return(RC_INVALID_OPERAND);
  2013.       }
  2014.     if (tabinc > 32)
  2015.       {
  2016.        display_error(6,word[1],FALSE);
  2017. #ifdef TRACE
  2018.        trace_return();
  2019. #endif
  2020.        return(RC_INVALID_OPERAND);
  2021.       }
  2022.     for (i=0;i<MAX_NUMTABS;i++)
  2023.        CURRENT_VIEW->tabs[i] = 1 + (tabinc*i);
  2024.     CURRENT_VIEW->numtabs = MAX_NUMTABS;
  2025.    }
  2026.  else
  2027. /*---------------------------------------------------------------------*/
  2028. /* ... individual TAB stop settings.                                   */
  2029. /*---------------------------------------------------------------------*/
  2030.    {
  2031.     if (num_params > MAX_NUMTABS)
  2032.       {
  2033.        display_error(2,(CHARTYPE *)"",FALSE);
  2034. #ifdef TRACE
  2035.        trace_return();
  2036. #endif
  2037.        return(RC_INVALID_OPERAND);
  2038.       }
  2039.     if (num_params == 0)
  2040.       {
  2041.        display_error(3,(CHARTYPE *)"",FALSE);
  2042. #ifdef TRACE
  2043.        trace_return();
  2044. #endif
  2045.        return(RC_INVALID_OPERAND);
  2046.       }
  2047.     for (i=0;i<num_params;i++)
  2048.       {
  2049.        if (!valid_positive_integer(word[i]))
  2050.          {
  2051.           display_error(4,word[i],FALSE);
  2052. #ifdef TRACE
  2053.           trace_return();
  2054. #endif
  2055.           return(RC_INVALID_OPERAND);
  2056.          }
  2057.        tabinc = (LENGTHTYPE)atoi(word[i]);
  2058.        if (i > 0)
  2059.          {
  2060.           if (stops[i-1] >= tabinc)
  2061.             {
  2062.              display_error(5,word[i],FALSE);
  2063. #ifdef TRACE
  2064.              trace_return();
  2065. #endif
  2066.              return(RC_INVALID_OPERAND);
  2067.             }
  2068.          }
  2069.        stops[i] = tabinc;
  2070.       }
  2071.     CURRENT_VIEW->numtabs = num_params;
  2072.     for (i=0;i<num_params;i++)
  2073.       {
  2074.        CURRENT_VIEW->tabs[i] = stops[i];
  2075.       }
  2076.    }
  2077.  build_current_screen();
  2078.  display_current_screen();
  2079. #ifdef TRACE
  2080.  trace_return();
  2081. #endif
  2082.  return(RC_OK);
  2083. }
  2084. /*man-start*********************************************************************
  2085. COMMAND
  2086.      tabsin - set tab processing on file input
  2087.  
  2088. SYNTAX
  2089.      [SET] TABSIn ON|OFF [n]
  2090.  
  2091. DESCRIPTION
  2092.      The TABSIN command determines if tabs read from a file are to be
  2093.      expanded to spaces and if so how many spaces.
  2094.  
  2095. COMPATIBILITY
  2096.      XEDIT: N/A
  2097.      KEDIT: Does not support TABQUOTE option.
  2098.  
  2099. DEFAULT
  2100.      OFF 8
  2101.  
  2102. SEE ALSO
  2103.      SET TABSOUT
  2104.  
  2105. STATUS
  2106.      Complete.
  2107. **man-end**********************************************************************/
  2108. #ifdef PROTO
  2109. short Tabsin(CHARTYPE *params)
  2110. #else
  2111. short Tabsin(params)
  2112. CHARTYPE *params;
  2113. #endif
  2114. /***********************************************************************/
  2115. {
  2116. /*---------------------------------------------------------------------*/
  2117. /* The settings for TABSIN is a global value, despite it supposedly    */
  2118. /* being a file level value.                                           */
  2119. /*---------------------------------------------------------------------*/
  2120. /*-------------------------- external data ----------------------------*/
  2121.  extern bool in_profile;
  2122.  extern CHARTYPE TABI_ONx;
  2123.  extern CHARTYPE TABI_Nx;
  2124. /*--------------------------- local data ------------------------------*/
  2125. #define TABI_PARAMS  3
  2126.  CHARTYPE *word[TABI_PARAMS+1];
  2127.  unsigned short num_params=0;
  2128.  short rc=RC_INVALID_OPERAND;
  2129.  CHARTYPE tabsts=TABI_ONx;
  2130.  CHARTYPE tabn  =TABI_Nx;
  2131. /*--------------------------- processing ------------------------------*/
  2132. #ifdef TRACE
  2133.  trace_function("commset2.c:Tabsin");
  2134. #endif
  2135. /*---------------------------------------------------------------------*/
  2136. /* Validate the parameters that have been supplied.                    */
  2137. /*---------------------------------------------------------------------*/
  2138.  num_params = param_split(params,word,TABI_PARAMS,WORD_DELIMS,TEMP_PARAM);
  2139.  switch(num_params)
  2140.    {
  2141. /*---------------------------------------------------------------------*/
  2142. /* Too few parameters, error.                                          */
  2143. /*---------------------------------------------------------------------*/
  2144.     case 0:
  2145.          display_error(3,(CHARTYPE *)"",FALSE);
  2146.          break;
  2147. /*---------------------------------------------------------------------*/
  2148. /* 1 or 2 parameters, validate them...                                 */
  2149. /*---------------------------------------------------------------------*/
  2150.     case 1:
  2151.     case 2:
  2152. /*---------------------------------------------------------------------*/
  2153. /* Validate first parameter; on or off...                              */
  2154. /*---------------------------------------------------------------------*/
  2155.          if (equal((CHARTYPE *)"on",word[0],2))
  2156.            {
  2157.             tabsts = TRUE;
  2158.             rc = RC_OK;
  2159.            }
  2160.          if (equal((CHARTYPE *)"off",word[0],3))
  2161.            {
  2162.             tabsts = FALSE;
  2163.             rc = RC_OK;
  2164.            }
  2165. /*---------------------------------------------------------------------*/
  2166. /* If not a valid first parameter, display an error and exit.          */
  2167. /*---------------------------------------------------------------------*/
  2168.          if (rc != RC_OK)
  2169.            {
  2170.             display_error(1,word[0],FALSE);
  2171.             break;
  2172.            }
  2173. /*---------------------------------------------------------------------*/
  2174. /* For 1 parameter, don't check any more.                              */
  2175. /*---------------------------------------------------------------------*/
  2176.          if (num_params == 1)
  2177.             break;
  2178. /*---------------------------------------------------------------------*/
  2179. /* Validate second parameter; number of spaces for a TAB...            */
  2180. /*---------------------------------------------------------------------*/
  2181.          if (!valid_positive_integer(word[1]))
  2182.            {
  2183.             display_error(4,word[1],FALSE);
  2184.             break;
  2185.            }
  2186.          tabn = (CHARTYPE)atoi(word[1]);
  2187. /*---------------------------------------------------------------------*/
  2188. /* tabn must be between 1 and 32...                                    */
  2189. /*---------------------------------------------------------------------*/
  2190.          if (tabn < 1)
  2191.            {
  2192.             display_error(5,word[1],FALSE);
  2193.             break;
  2194.            }
  2195.          if (tabn > 32)
  2196.            {
  2197.             display_error(6,word[1],FALSE);
  2198.             break;
  2199.            }
  2200.          rc = RC_OK;
  2201.          break;
  2202. /*---------------------------------------------------------------------*/
  2203. /* Too many parameters...                                              */
  2204. /*---------------------------------------------------------------------*/
  2205.     default:
  2206.          display_error(2,(CHARTYPE *)"",FALSE);
  2207.          break;
  2208.    }
  2209. /*---------------------------------------------------------------------*/
  2210. /* If valid parameters, change the settings...                         */
  2211. /*---------------------------------------------------------------------*/
  2212.  if (rc == RC_OK)
  2213.    {
  2214.     TABI_ONx = tabsts;
  2215.     TABI_Nx = tabn;
  2216. /*---------------------------------------------------------------------*/
  2217. /* If this command is issued from the profile file, we need to run     */
  2218. /* EXPAND ALL on it, as we have already read in the file.              */
  2219. /* Of course if TABSIN OFF was set we DON'T run EXPAND ALL :-)         */
  2220. /*---------------------------------------------------------------------*/
  2221.     if (in_profile && tabsts)
  2222.        rc = execute_expand("ALL",FALSE,FALSE,FALSE);
  2223.    }
  2224. #ifdef TRACE
  2225.  trace_return();
  2226. #endif
  2227.  return(rc);
  2228. }
  2229. /*man-start*********************************************************************
  2230. COMMAND
  2231.      tabsout - set tab processing on file output
  2232.  
  2233. SYNTAX
  2234.      [SET] TABSOut ON|OFF [n]
  2235.  
  2236. DESCRIPTION
  2237.      The TABSOUT command determines if spaces written to a file are to be
  2238.      compressed to tabs and if so how many spaces.
  2239.  
  2240. COMPATIBILITY
  2241.      XEDIT: N/A
  2242.      KEDIT: Compatible.
  2243.  
  2244. DEFAULT
  2245.      OFF 8
  2246.  
  2247. SEE ALSO
  2248.      SET TABSIN
  2249.  
  2250. STATUS
  2251.      Complete.
  2252. **man-end**********************************************************************/
  2253. #ifdef PROTO
  2254. short Tabsout(CHARTYPE *params)
  2255. #else
  2256. short Tabsout(params)
  2257. CHARTYPE *params;
  2258. #endif
  2259. /***********************************************************************/
  2260. {
  2261. /*-------------------------- external data ----------------------------*/
  2262. /*--------------------------- local data ------------------------------*/
  2263. #define TABO_PARAMS  3
  2264.  CHARTYPE *word[TABO_PARAMS+1];
  2265.  unsigned short num_params=0;
  2266.  short rc=RC_INVALID_OPERAND;
  2267.  bool tabsts=CURRENT_FILE->tabsout_on;
  2268.  CHARTYPE tabn=CURRENT_FILE->tabsout_num;
  2269. /*--------------------------- processing ------------------------------*/
  2270. #ifdef TRACE
  2271.  trace_function("commset2.c:Tabsout");
  2272. #endif
  2273. /*---------------------------------------------------------------------*/
  2274. /* Validate the parameters that have been supplied.                    */
  2275. /*---------------------------------------------------------------------*/
  2276.  num_params = param_split(params,word,TABO_PARAMS,WORD_DELIMS,TEMP_PARAM);
  2277.  switch(num_params)
  2278.    {
  2279. /*---------------------------------------------------------------------*/
  2280. /* Too few parameters, error.                                          */
  2281. /*---------------------------------------------------------------------*/
  2282.     case 0:
  2283.          display_error(3,(CHARTYPE *)"",FALSE);
  2284.          break;
  2285. /*---------------------------------------------------------------------*/
  2286. /* 1 or 2 parameters, validate them...                                 */
  2287. /*---------------------------------------------------------------------*/
  2288.     case 1:
  2289.     case 2:
  2290. /*---------------------------------------------------------------------*/
  2291. /* Validate first parameter; on or off...                              */
  2292. /*---------------------------------------------------------------------*/
  2293.          if (equal((CHARTYPE *)"on",word[0],2))
  2294.            {
  2295.             tabsts = TRUE;
  2296.             rc = RC_OK;
  2297.            }
  2298.          if (equal((CHARTYPE *)"off",word[0],3))
  2299.            {
  2300.             tabsts = FALSE;
  2301.             rc = RC_OK;
  2302.            }
  2303. /*---------------------------------------------------------------------*/
  2304. /* If not a valid first parameter, display an error and exit.          */
  2305. /*---------------------------------------------------------------------*/
  2306.          if (rc != RC_OK)
  2307.            {
  2308.             display_error(1,word[0],FALSE);
  2309.             break;
  2310.            }
  2311. /*---------------------------------------------------------------------*/
  2312. /* For 1 parameter, don't check any more.                              */
  2313. /*---------------------------------------------------------------------*/
  2314.          if (num_params == 1)
  2315.             break;
  2316. /*---------------------------------------------------------------------*/
  2317. /* Validate second parameter; number of spaces for a TAB...            */
  2318. /*---------------------------------------------------------------------*/
  2319.          if (!valid_positive_integer(word[1]))
  2320.            {
  2321.             display_error(4,word[1],FALSE);
  2322.             break;
  2323.            }
  2324.          tabn = (CHARTYPE)atoi(word[1]);
  2325. /*---------------------------------------------------------------------*/
  2326. /* tabn must be between 1 and 32...                                    */
  2327. /*---------------------------------------------------------------------*/
  2328.          if (tabn < 1)
  2329.            {
  2330.             display_error(5,word[1],FALSE);
  2331.             break;
  2332.            }
  2333.          if (tabn > 32)
  2334.            {
  2335.             display_error(6,word[1],FALSE);
  2336.             break;
  2337.            }
  2338.          rc = RC_OK;
  2339.          break;
  2340. /*---------------------------------------------------------------------*/
  2341. /* Too many parameters...                                              */
  2342. /*---------------------------------------------------------------------*/
  2343.     default:
  2344.          display_error(2,(CHARTYPE *)"",FALSE);
  2345.          break;
  2346.    }
  2347. /*---------------------------------------------------------------------*/
  2348. /* If valid parameters, change the settings...                         */
  2349. /*---------------------------------------------------------------------*/
  2350.  if (rc == RC_OK)
  2351.    {
  2352.     CURRENT_FILE->tabsout_on = tabsts;
  2353.     CURRENT_FILE->tabsout_num = tabn;
  2354.    }
  2355. #ifdef TRACE
  2356.  trace_return();
  2357. #endif
  2358.  return(RC_OK);
  2359. }
  2360. /*man-start*********************************************************************
  2361. COMMAND
  2362.      typeahead - set behavior of screen redraw
  2363.  
  2364. SYNTAX
  2365.      [SET] TYPEAhead ON|OFF
  2366.  
  2367. DESCRIPTION
  2368.      The TYPEAHEAD set command determines whether of not THE uses the
  2369.      curses screen display optimization techniques.
  2370.      With TYPEAHEAD ON, curses will abort screen display if a keystroke
  2371.      is pending.
  2372.      With TYPEAHEAD OFF, curses will not abort screen display if a
  2373.      keystroke is pending.
  2374.      For BSD based curses, this function has no effect.
  2375.  
  2376. COMPATIBILITY
  2377.      XEDIT: N/A
  2378.      KEDIT: N/A
  2379.  
  2380. DEFAULT
  2381.      ON
  2382.  
  2383. STATUS
  2384.      Complete.
  2385. **man-end**********************************************************************/
  2386. #ifdef PROTO
  2387. short THETypeahead(CHARTYPE *params)
  2388. #else
  2389. short THETypeahead(params)
  2390. CHARTYPE *params;
  2391. #endif
  2392. /***********************************************************************/
  2393. {
  2394. /*-------------------------- external data ----------------------------*/
  2395.  extern bool curses_started;
  2396. /*--------------------------- local data ------------------------------*/
  2397.  short rc=RC_OK;
  2398.  bool setting=FALSE;
  2399. /*--------------------------- processing ------------------------------*/
  2400. #ifdef TRACE
  2401.  trace_function("commset2.c:THETypeahead");
  2402. #endif
  2403.  
  2404. #if !defined(BSD) && !defined(USE_NCURSES) && !defined(USE_EXTCURSES)
  2405.  if (curses_started)
  2406.    {
  2407.     rc = execute_set_on_off(params,&setting);
  2408.     if (rc == RC_OK)
  2409.       {
  2410.        if (setting)
  2411. #if defined(DOS) || defined(OS2)
  2412.           typeahead(1);
  2413. #else
  2414.           typeahead(stdin);
  2415. #endif
  2416.        else
  2417.           typeahead(-1);
  2418.       }
  2419.    }
  2420. #endif
  2421.  
  2422. #ifdef TRACE
  2423.  trace_return();
  2424. #endif
  2425.  return(rc);
  2426. }
  2427. /*man-start*********************************************************************
  2428. COMMAND
  2429.      verify - set column display limits
  2430.  
  2431. SYNTAX
  2432.      [SET] Verify first [last]
  2433.  
  2434. DESCRIPTION
  2435.      The VERIFY command sets the column limits for the display of the
  2436.      current file. 'first' specifies the first column to be displayed
  2437.      and 'last' specifies the last column to be displayed.
  2438.  
  2439.      If no 'last' option is specified '*' is assumed.
  2440.  
  2441. COMPATIBILITY
  2442.      XEDIT: Does not implement HEX display nor multiple column pairs.
  2443.      KEDIT: Does not implement HEX display nor multiple column pairs.
  2444.  
  2445. DEFAULT
  2446.      1 *
  2447.  
  2448. SEE ALSO
  2449.      SET ZONE
  2450.  
  2451. STATUS
  2452.      Complete.
  2453. **man-end**********************************************************************/
  2454. #ifdef PROTO
  2455. short Verify(CHARTYPE *params)
  2456. #else
  2457. short Verify(params)
  2458. CHARTYPE *params;
  2459. #endif
  2460. /***********************************************************************/
  2461. {
  2462. /*-------------------------- external data ----------------------------*/
  2463. /*--------------------------- local data ------------------------------*/
  2464. #define VER_PARAMS  2
  2465.  CHARTYPE *word[VER_PARAMS+1];
  2466.  unsigned short num_params=0;
  2467.  LINETYPE col1=0L,col2=0L;
  2468. /*--------------------------- processing ------------------------------*/
  2469. #ifdef TRACE
  2470.  trace_function("commset2.c:Verify");
  2471. #endif
  2472. /*---------------------------------------------------------------------*/
  2473. /* Validate the parameters that have been supplied. One or two         */
  2474. /* parameters can be supplied. The first parameter MUST be a positive  */
  2475. /* integer. The second can be a positive integer or '*'. If no second  */
  2476. /* parameter is supplied, '*' is assumed. The second parameter MUST be */
  2477. /* >= first parameter. '*' is regarded as the biggest number and is    */
  2478. /* literally max_line_length.                                          */
  2479. /*---------------------------------------------------------------------*/
  2480.  num_params = param_split(params,word,VER_PARAMS,WORD_DELIMS,TEMP_PARAM);
  2481.  if (num_params == 0)
  2482.    {
  2483.     display_error(3,(CHARTYPE *)"",FALSE);
  2484. #ifdef TRACE
  2485.     trace_return();
  2486. #endif
  2487.     return(RC_INVALID_OPERAND);
  2488.    }
  2489.  if (num_params > 2)
  2490.    {
  2491.     display_error(2,(CHARTYPE *)"",FALSE);
  2492. #ifdef TRACE
  2493.     trace_return();
  2494. #endif
  2495.     return(RC_INVALID_OPERAND);
  2496.    }
  2497.  if (!valid_positive_integer(word[0]))
  2498.    {
  2499.     display_error(4,word[0],FALSE);
  2500. #ifdef TRACE
  2501.     trace_return();
  2502. #endif
  2503.     return(RC_INVALID_OPERAND);
  2504.    }
  2505.  col1 = atol(word[0]);
  2506.  if (num_params == 1)
  2507.      col2 = max_line_length;
  2508.  else
  2509.      if (strcmp(word[1],"*") == 0)
  2510.         col2 = max_line_length;
  2511.      else
  2512.         if (!valid_positive_integer(word[1]))
  2513.           {
  2514.            display_error(4,word[1],FALSE);
  2515. #ifdef TRACE
  2516.            trace_return();
  2517. #endif
  2518.            return(RC_INVALID_OPERAND);
  2519.           }
  2520.         else
  2521.            col2 = atol(word[1]);
  2522.  
  2523.  if (col2 > max_line_length)
  2524.     col2 = max_line_length;
  2525.  if (col1 > col2)
  2526.    {
  2527.     display_error(6,word[0],FALSE);
  2528. #ifdef TRACE
  2529.     trace_return();
  2530. #endif
  2531.     return(RC_INVALID_OPERAND);
  2532.    }
  2533.  CURRENT_VIEW->verify_start = (LENGTHTYPE)col1;
  2534.  CURRENT_VIEW->verify_col = (LENGTHTYPE)col1;
  2535.  CURRENT_VIEW->verify_end = (LENGTHTYPE)col2;
  2536.  
  2537.  build_current_screen();
  2538.  display_current_screen();
  2539.  
  2540. #ifdef TRACE
  2541.  trace_return();
  2542. #endif
  2543.  return(RC_OK);
  2544. }
  2545. /*man-start*********************************************************************
  2546. COMMAND
  2547.      wordwrap - set wordwrap feature on or off
  2548.  
  2549. SYNTAX
  2550.      [SET] WORDWrap ON|OFF
  2551.  
  2552. DESCRIPTION
  2553.      The WORDWRAP set command determines whether wordwrap occurs when
  2554.      the cursor moves past the right margin (as set my [SET] MARGINS
  2555.      command).
  2556.      With WORDWRAP ON, the line, from the beginning of the word that
  2557.      exceeds the right margin, is wrapped onto the next line. The cursor
  2558.      position stays in the same position relative to the current word.
  2559.      WIth WORDWRAP OFF, no word wrap occurs.
  2560.  
  2561. COMPATIBILITY
  2562.      XEDIT: N/A
  2563.      KEDIT: Compatible.
  2564.  
  2565. DEFAULT
  2566.      OFF
  2567.  
  2568. SEE ALSO
  2569.      SET MARGINS
  2570.  
  2571. STATUS
  2572.      Complete.
  2573. **man-end**********************************************************************/
  2574. #ifdef PROTO
  2575. short Wordwrap(CHARTYPE *params)
  2576. #else
  2577. short Wordwrap(params)
  2578. CHARTYPE *params;
  2579. #endif
  2580. /***********************************************************************/
  2581. {
  2582. /*-------------------------- external data ----------------------------*/
  2583. /*--------------------------- local data ------------------------------*/
  2584.  short rc=RC_OK;
  2585. /*--------------------------- processing ------------------------------*/
  2586. #ifdef TRACE
  2587.  trace_function("commset2.c:Wordwrap");
  2588. #endif
  2589.  rc = execute_set_on_off(params,&CURRENT_VIEW->wordwrap);
  2590. #ifdef TRACE
  2591.  trace_return();
  2592. #endif
  2593.  return(rc);
  2594. }
  2595. /*man-start*********************************************************************
  2596. COMMAND
  2597.      zone - set column limits for editing
  2598.  
  2599. SYNTAX
  2600.      [SET] Zone first [last]
  2601.  
  2602. DESCRIPTION
  2603.      The ZONE command sets the column limits for various other editor
  2604.      commands, such as 'locate' and 'change'. It effectively restricts
  2605.      to the specified columns those parts of the file which can be
  2606.      acted upon.
  2607.  
  2608.      If no 'last' option is specified '*' is assumed.
  2609.  
  2610. COMPATIBILITY
  2611.      XEDIT: Compatible.
  2612.      KEDIT: Compatible.
  2613.  
  2614. DEFAULT
  2615.      1 *
  2616.  
  2617. SEE ALSO
  2618.      SET VERIFY
  2619.  
  2620. STATUS
  2621.      Complete.
  2622. **man-end**********************************************************************/
  2623. #ifdef PROTO
  2624. short Zone(CHARTYPE *params)
  2625. #else
  2626. short Zone(params)
  2627. CHARTYPE *params;
  2628. #endif
  2629. /***********************************************************************/
  2630. {
  2631. /*-------------------------- external data ----------------------------*/
  2632. /*--------------------------- local data ------------------------------*/
  2633. #define ZON_PARAMS  2
  2634.  CHARTYPE *word[ZON_PARAMS+1];
  2635.  unsigned short num_params=0;
  2636.  LINETYPE col1=0L,col2=0L;
  2637. /*--------------------------- processing ------------------------------*/
  2638. #ifdef TRACE
  2639.  trace_function("commset2.c:Zone");
  2640. #endif
  2641. /*---------------------------------------------------------------------*/
  2642. /* Validate the parameters that have been supplied. One only           */
  2643. /* parameter MUST be supplied. The first parameter MUST be a positive  */
  2644. /* integer. The second can be a positive integer or '*'. If no second  */
  2645. /* parameter is supplied, ERROR.          The second parameter MUST be */
  2646. /* >= first parameter. '*' is regarded as the biggest number and is    */
  2647. /* literally max_line_length.                                          */
  2648. /*---------------------------------------------------------------------*/
  2649.  num_params = param_split(params,word,ZON_PARAMS,WORD_DELIMS,TEMP_PARAM);
  2650.  if (num_params < 2)
  2651.    {
  2652.     display_error(3,(CHARTYPE *)"",FALSE);
  2653. #ifdef TRACE
  2654.     trace_return();
  2655. #endif
  2656.     return(RC_INVALID_OPERAND);
  2657.    }
  2658.  if (num_params > 2)
  2659.    {
  2660.     display_error(2,(CHARTYPE *)"",FALSE);
  2661. #ifdef TRACE
  2662.     trace_return();
  2663. #endif
  2664.     return(RC_INVALID_OPERAND);
  2665.    }
  2666.  if (!valid_positive_integer(word[0]))
  2667.    {
  2668.     display_error(4,word[0],FALSE);
  2669. #ifdef TRACE
  2670.     trace_return();
  2671. #endif
  2672.     return(RC_INVALID_OPERAND);
  2673.    }
  2674.  col1 = atol(word[0]);
  2675.  if (strcmp(word[1],"*") == 0)
  2676.     col2 = max_line_length;
  2677.  else
  2678.     if (!valid_positive_integer(word[1]))
  2679.       {
  2680.        display_error(4,word[1],FALSE);
  2681. #ifdef TRACE
  2682.        trace_return();
  2683. #endif
  2684.        return(RC_INVALID_OPERAND);
  2685.       }
  2686.     else
  2687.        col2 = atol(word[1]);
  2688.  
  2689.  if (col2 > max_line_length)
  2690.     col2 = max_line_length;
  2691.  if (col1 > col2)
  2692.    {
  2693.     display_error(6,word[0],FALSE);
  2694. #ifdef TRACE
  2695.     trace_return();
  2696. #endif
  2697.     return(RC_INVALID_OPERAND);
  2698.    }
  2699.  CURRENT_VIEW->zone_start = (LENGTHTYPE)col1;
  2700.  CURRENT_VIEW->zone_end   = (LENGTHTYPE)col2;
  2701. /*---------------------------------------------------------------------*/
  2702. /* If the SCALE line is currently displayed, display the page so that  */
  2703. /* any changes are reflected in the SCALE line.                        */
  2704. /*---------------------------------------------------------------------*/
  2705.  if (CURRENT_VIEW->scale_on)
  2706.    {
  2707.     build_current_screen();
  2708.     display_current_screen();
  2709.    }
  2710. #ifdef TRACE
  2711.  trace_return();
  2712. #endif
  2713.  return(RC_OK);
  2714. }
  2715.